A Fast Suffix-Sorting Algorithm

We present an algorithm to sort all suffixes of x = (x1, . . . , xn) ∈ Xn lexicographically, where X = {0, . . . , q−1}. Fast and efficient sorting of a large amount of data according to its suffix structure (suffix-sorting) is a useful technology in many fields of application, front-most in the field of Data Compression where it is used e.g. for the Burrows and Wheeler Transformation (BWT for short), a block-sorting transformation ([3],[9]). Larsson [4] describes the relationship between the BWT on one hand and suffix trees and context trees on the other hand. Then Sadakane [8] suggests a well referenced method to compute the BWT more time efficiently. Then the algorithms based on suffix trees have been improved ([6],[5],[1]). In [3] it was observed that for an input string of size n, this transformation can be computed in O(n) time and space using suffix trees. While suffix trees are considered to be greedy in space – even small factors hidden in the O-notation may decide on the feasibility of an algorithm – sorting was accomplished by alternative non-linear methods: Manber and Myers [7] introduced an algorithm of O(n log n) in worst case time and 8n bytes of space and in [2] an algorithm based on Quicksort is suggested, which is fast on the average but its worst case complexity is O(n logn). Most prominent in this case is the Bendson-Sedgewick Algorithm which requires 4n bytes and Sadakane’s example of a combination of the Manber-Myers Algorithm with the Bendson-Sedgewick Algorithm with a complexity of O(nlogn) worst case time using 9n bytes [8]. The reduction of the space requirement due to an upper bound on n seems trivial. However, it turns out that it involves a considerable amount of engineering work to achieve an improvement, while retaining an acceptable worst case time complexity. This paper proposes an algorithm, efficient in the terms described above, ideal for handling large blocks of input data. We assume that the cardinality of the alphabet (q) is smaller than the text-string (n). Our algorithm computes the suffix sorting in O(n) space and O(n logn) time in the worst case. It has also the property that it sorts the suffixes lexicographically according to the prefixes of length t2 = logq n2 in the worst case in linear time. After the initial sorting of length t2, we use a Quick-sort-variant to sort the remaining part. Therefore we get the worst time O(n logn). It is also possible to modify our algorithm by using Heap-sort. Then we will get a worst case time O(n(log n)).